package com.bs.areport.action.basic;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.bs.areport.service.basic.ChargeDao;
import com.bs.restframework.context.SystemContext;
import com.bs.restframework.web.result.ResultModle;
import com.bs.restframework.web.result.ResultType;

/**
 * 
 * @ClassName   类名：ChargeAction 
 * @Description 功能说明：收费项目控制类
 * TODO
 ************************************************************************
 * @date        创建日期：2012-03-08
 * @author      创建人：陈金滨
 * @version     版本号：V1.0
 ***************************修订记录*************************************
 * 
 * 2012-03-08   陈金滨     创建类
 *   
 ***********************************************************************
 */
public class ChargeAction {
	
	private ChargeDao dao;
	public  ChargeDao getDao() {
		return dao;
	}

	public void setDao(ChargeDao dao) {
		this.dao = dao;
	}
	
	/**
	 * 
	 * <p>函数名称：list</p>
	 * <p>功能说明：查询列表</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-08</p>
	 * <p>作者：李新宇</p>
	 */
	public ResultModle list() throws Exception
	{
		Map<String, Object> params = SystemContext.getInParams();
		
        Map<String, Object> resultBean = dao.list(params);
        
		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);
	}
	/**
	 * 
	 * <p>函数名称：qrylist</p>
	 * <p>功能说明：点击树查询并刷新网格</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-28</p>
	 * <p>作者：陈金滨</p>
	 */
	public ResultModle qrylist() throws Exception
	{
		Map<String, Object> params = SystemContext.getInParams();
		
        Map<String, Object> resultBean = dao.qrylist(params);
        
		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);
	}	
	/**
	 * 
	 * <p>函数名称：tree</p>
	 * <p>功能说明：获取单位树</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-13</p>
	 * <p>作者：李新宇</p>
	 */
	public ResultModle tree() throws Exception
	{
		Map<String, Object> params = SystemContext.getInParams();
		
        List<Map> listMap = dao.tree(params);
               
		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", listMap);
	}
	
	
	/**
	 * 
	 * <p>函数名称：getMaxCode</p>
	 * <p>功能说明：获取最大编码值/p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-08</p>
	 * <p>作者：陈金滨</p>
	 */
	public ResultModle getMaxCode() throws Exception	
	{				
		Map<String, Object> params = SystemContext.getInParams();
		String Code = (String) params.get("F_CODE");
		if(Code==null||Code.length()==0)
			Code = "" ;
		Map<String, Object> resultBean=dao.getMaxCode(Code);
		
		String maxCode=(String)resultBean.get("F_CODE");
		int codelen = maxCode.length() ;
		String strRight = "" ;
		String strLeft = "" ;
		if(codelen>9)
		{
			strLeft = maxCode.substring(0, codelen-9).toString();
			strRight = maxCode.substring(codelen-9,codelen).toString();
		}
		else
		{
			strRight = maxCode ;
		}
		int oldcode = Integer.valueOf(strRight).intValue();
		oldcode = oldcode + 1 ;
		String newCode = String.valueOf(oldcode).toString();
		int codelen2 = newCode.length();
		codelen = strRight.length();
		if(codelen2<codelen)
		{
			for(int i=0;i<(codelen-codelen2);i++)
			{
				newCode = "0"+newCode ;
			}			
		}
		newCode = strLeft + newCode ;
		resultBean.put("F_CODE", newCode);		
		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);
	}	
	
	/**
	 * 
	 * <p>函数名称：edit</p>
	 * <p>功能说明：编辑</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-08</p>
	 * <p>作者：陈金滨</p>
	 * @throws Exception 
	 */
	public ResultModle edit() throws Exception{
		Map<String, Object> params = SystemContext.getInParams();
        String code = (String) params.get("F_CODE");
        String chgrID = (String) params.get("F_ID");
		//处理分成比例，将四个值合并成一个
		String fs1 = (String) params.get("F_DIVIRATIO1").toString().trim();
		String fs2 = (String) params.get("F_DIVIRATIO2").toString().trim();
		String fs3 = (String) params.get("F_DIVIRATIO3").toString().trim();
		String fs4 = (String) params.get("F_DIVIRATIO4").toString().trim();
		String payRatio = (String) params.get("F_PAYRATIO");
		@SuppressWarnings("unused")
		String diviRaito = fs1+":"+fs2+":"+fs3+":"+fs4;
		params.remove("F_DIVIRATIO1");
		params.remove("F_DIVIRATIO2");
		params.remove("F_DIVIRATIO3");
		params.remove("F_DIVIRATIO4");
		if(diviRaito.length()==3)
		{
			diviRaito = " " ;
		}
		params.put("F_DIVIRATIO", diviRaito);
		//最后修改时间
        Date currentTime = new Date();
	    SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmsssss");
	    String dateString = formatter.format(currentTime);		
	    params.put("F_LASTTIME", dateString);	
	    //是否代收
		String iscoll = (String) params.get("F_ISCOLL");
		if((iscoll==null)||(iscoll.isEmpty()))
		{
			params.put("F_ISCOLL", "0");
		}
		else
		{
			params.put("F_ISCOLL", "1");
		}       
		int level = dao.getLevel(code);
		params.put("F_LEVEL", String.valueOf(level).toString());
		params.put("F_ISLEAF", "0");
        String vDWJC = this.getDWJC();
		boolean tag = false;
		String codeByID= dao.getCodeByID(chgrID);    //取得修改前的编码
		String msg = "";
		String upbm = dao.getUpBM(code);
		boolean isUpbmExist = true ;
		String upbmOld = dao.getUpBM(codeByID);
		String ChgCode = code+" | "+upbmOld+" | "+upbm ;
		if(upbm.length()>0)
		{
			if(codeByID.equals(upbm))  //如果修改后的编码，其上级编码 和 未修改前相同，则提示没有上级
			{
				isUpbmExist = false ;
			}else{
				isUpbmExist = dao.isBmExist(upbm); //判断上级编码是否存在，控制不能直接增加不存在上级的项目
			}
		}		
		try
		{   
			boolean isBmExist = dao.isBmExist(code);
			boolean isBmRight = this.isBmFixJC(code);
			@SuppressWarnings("unused")
			boolean isDownXmExist = false ;
			if(code.equals(codeByID)==false)
			{
				isDownXmExist=dao.isDownXMExist(codeByID);	
			}
			
			if(isBmRight==true)  //判断编码 是否符合系统要求
			{
				if((isBmExist==true)&&((codeByID.equals(code))==false)) //如果编码修改过，并在数据库中有记录则不允许修改
				{
					msg = "编码已存在，请重新输入!" ;
				}
				else
				{		
					if(isUpbmExist)
					{
						if(isDownXmExist==false)
						{
//							msg = this.IsBmNum(code);
							if ("".equals(msg))
							{                               						
							    msg = dao.edit(params);
//							    if("".equals(Upbm )==false)
	                            dao.changeUpleaf(ChgCode, "修改");	
								tag = true;
								msg = "修改成功!";
							}		
						}
						else
						{
							msg = "存在下级项目,编码不能修改!" ;
						}
					}
					else
					{
						msg = "上级项目不存在,请先增加上级项目!" ;
					}
											
				}

			}
			else
			{
				msg = "编码级长不符合预定规则:"+vDWJC+"!"  ;
			}
		}
		catch(Exception e)
		{
			msg = "修改失败" + e;
		}
        
		Map<String, Object> resultBean=new HashMap<String, Object>();
		resultBean.put("msg", msg);
		resultBean.put("tag", tag);
		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);

	}
	
	/**
	 * 
	 * <p>函数名称：del</p>
	 * <p>功能说明：删除，只删除最细级节点</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-08</p>
	 * <p>作者：陈金滨</p>
	 */
	public ResultModle del() throws Exception{
		Map<String, Object> params = SystemContext.getInParams(); 
	    String charID = (String) params.get("F_ID");
	    String codeByID = dao.getCodeByID(charID);
	    String upCode = dao.getUpBM(codeByID);
		boolean tag=false;
		
		//判断是否是最细级，最细级才能删除，最细级节点返回true
		boolean isLeaf = dao.isLeaf(charID);
		boolean isChrUsed = dao.isChrUsed(charID);
		String msg =""; 
		try
		{   if(!isLeaf)
		    {
				if(isChrUsed)
				{
					msg = "项目已被使用,不能删除!" ;
				}
				else
				{					
					msg = dao.del(params);					
					if("".equals(msg))
					{
						tag = true;
						msg = "删除成功!";
					}
					else
					{
						msg = "删除失败!";
					}	
					if(upCode!=null&"".equals(upCode)==false)
					{
						dao.changeUpleaf(upCode, "删除");
					}
				}			    
		    }
		    else
		    {
		    	msg="存在下级项目,不能删除!";		    	
		    }	

		}
		catch(Exception e)
		{
			msg = "删除失败!" + e;
		}
		
		Map<String, Object> resultBean=new HashMap<String, Object>();
		resultBean.put("msg", msg);
		resultBean.put("tag", tag);
		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);

	}
	
	/**
	 * 
	 * <p>函数名称：add</p>
	 * <p>功能说明：添加</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-08</p>
	 * <p>作者：陈金滨</p>
	 * @throws Exception 
	 */
	public ResultModle add() throws Exception{
		Map<String, Object> params = SystemContext.getInParams();
		boolean tag = false;
		String code = (String) params.get("F_CODE");
		//处理分成比例，将四个值合并成一个
		String fs1 = (String) params.get("F_DIVIRATIO1").toString().trim();
		String fs2 = (String) params.get("F_DIVIRATIO2").toString().trim();
		String fs3 = (String) params.get("F_DIVIRATIO3").toString().trim();
		String fs4 = (String) params.get("F_DIVIRATIO4").toString().trim();
		String sj = (String) params.get("F_PAYRATIO");
		@SuppressWarnings("unused")
		String diviratio = fs1+":"+fs2+":"+fs3+":"+fs4;
		params.remove("F_DIVIRATIO1");
		params.remove("F_DIVIRATIO2");
		params.remove("F_DIVIRATIO3");
		params.remove("F_DIVIRATIO4");
		if(diviratio.length()==3)
		{
			diviratio = " " ;
		}
		params.put("F_DIVIRATIO", diviratio);
		String iscoll = (String) params.get("F_ISCOLL");
		if((iscoll==null)||(iscoll.isEmpty()))
		{
			params.put("F_ISCOLL", "0");
		}
		else
		{
			params.put("F_ISCOLL", "1");
		}
		
		String vDWJC =getDWJC();//取单位级长		
		String msg = "";
		int leave,isleaf,lenJC,temp ;
		lenJC = vDWJC.length();
		temp = 0; leave = -1 ;
		//判断级数
		leave = dao.getLevel(code);
		isleaf = 1 ;
		String upbm = dao.getUpBM(code) ;		
		boolean isUpbmFix = true ;
		if(upbm==null||"".equals(upbm))
		{
			msg = "" ;
		}
		else
		{
			boolean IsUpbmExist = dao.isBmExist(upbm);
			if((!IsUpbmExist)&&leave>1)
			{
				isUpbmFix = false ;
			}
		}
	    Date currentTime = new Date();
	    SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmsssss");
	    String dateString = formatter.format(currentTime);
	    params.put("F_LEVEL", leave);
	    params.put("F_ISLEAF", isleaf);
	    params.put("F_LASTTIME", dateString);
		try
		{
			if(leave==-1)
			{
				msg = "编码级长不符合预定规则:"+vDWJC+"!"  ;
			}
			else
			{
//				msg=this.IsBmNum(code);
				if("".equals(msg))
				{
					boolean isCodeExist = dao.isBmExist(code);
					boolean isCodeRight = this.isBmFixJC(code);
					if(isCodeRight==true)   //判断编码是否符合级长规范
					{
						if(isCodeExist!=true)  //判断编码是否已经存在
						{   	
							if(!isUpbmFix)
							{msg = "不存在上级项目,请先增加上级项目!" ;}
							if("".equals(msg))
							{   
								msg = dao.add(params);
								//更改上级最细级字段
								boolean IsChange = dao.changeUpleaf(upbm,"新增");
						
								tag = true;
								msg = "新增成功!";
							}
						}
						else
						{
							msg ="已存在此编码，请重新输入!";
						}	
					}	
					else
					{
						msg = "编码级长不符合预定规则:"+vDWJC+"!"  ;
					}				
				}
			}			
		}
		catch(Exception e)
		{
			msg = "新增失败" + e;
		}
		Map<String, Object> resultBean=new HashMap<String, Object>();
		resultBean.put("msg", msg);
		resultBean.put("tag", tag);
		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);

	}

	/**
	 * 
	 * <p>函数名称：initGvndeptid</p>
	 * <p>功能说明：取财政单位下拉列表</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-15</p>
	 * <p>作者：陈金滨</p>
	 */
//	public ResultModle initGvndeptid() throws Exception
//	{				
//		List<Map> resultBean=dao.initGvndeptid();
//		
//		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);
//	}	
	
	/**
	 * 
	 * <p>函数名称：getDWJC</p>
	 * <p>功能说明：获取最大编码值/p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-08</p>
	 * <p>作者：陈金滨</p>
	 * @param MaxCode 
	 */
	public String getDWJC() throws Exception
	{			
		String result = "" ;
		Map<String, Object> resultBean=dao.getDWJC();
		result = (String) resultBean.get("F_ITEM1");

		return result;
	}	
	/**
	 * 
	 * <p>函数名称：IsBmExist</p>
	 * <p>功能说明：判断编码是否存在/p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-19</p>
	 * <p>作者：陈金滨</p>
	 * @param <Boolen>
	 * @param MaxCode 
	 */
//	public <Boolen> boolean IsBmExist(String Code) throws Exception
//	{				
//		boolean result = dao.isBmExist(Code);
//		
//		return result;
//	}		
	/**
	 * 
	 * <p>函数名称：IsDownXMExist</p>
	 * <p>功能说明：判断是否存在下级项目</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-04-06</p>
	 * <p>作者：陈金滨</p>
	 * @param <Boolen>
	 * @param MaxCode 
	 */
//	public <Boolen> boolean IsDownXMExist(String Code) throws Exception
//	{				
//		boolean result = dao.isDownXMExist(Code);
//		
//		return result;
//	}		
	/**
	 * 
	 * <p>函数名称：ChangeUpleaf</p>
	 * <p>功能说明：修改上级节点最细级字段/p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-19</p>
	 * <p>作者：陈金滨</p>
	 * @param <Boolen>
	 * @param MaxCode 
	 */
//	public <Boolen> boolean ChangeUpleaf(String Code,String BusType) throws Exception
//	{				
//		boolean result = dao.changeUpleaf(Code,BusType);
//		
//		return result;
//	}		
	/**
	 * 
	 * <p>函数名称：IsLeaf</p>
	 * <p>功能说明：修改上级节点最细级字段/p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-19</p>
	 * <p>作者：陈金滨</p>
	 * @param <Boolen>
	 * @param MaxCode 
	 */
//	public <Boolen> boolean IsLeaf(String ID) throws Exception
//	{				
//		boolean result = dao.isLeaf(ID);
//		
//		return result;
//	}		
	
	/**
	 * 
	 * <p>函数名称：isBmFixJC</p>
	 * <p>功能说明：判断编码是否符合级长规范</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-19</p>
	 * <p>作者：陈金滨</p>
	 * @param <Boolen>
	 * @param MaxCode 
	 */
	public boolean isBmFixJC(String code) throws Exception
	{				
		boolean result = false ;
		int js = dao.getLevel(code) ;//求编码级数，-1 为不符合级长要求
		if(js!=-1)
		{
			result = true ;	
		}		
		return result;
	}	
	/**
	 * 
	 * <p>函数名称：getJC</p>
	 * <p>功能说明：获取最大编码值/p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-08</p>
	 * <p>作者：陈金滨</p>
	 * @param MaxCode 
	 */
	public ResultModle getJC() throws Exception
	{				
		Map<String, Object> resultBean=dao.getDWJC();

		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);
	}			
	/**
	 * 
	 * <p>函数名称：SetJC</p>
	 * <p>功能说明：设置级长</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-27</p>
	 * <p>作者：陈金滨</p>
	 * @throws Exception 
	 */
	public ResultModle setJC() throws Exception{
		Map<String, Object> params = SystemContext.getInParams();
		boolean tag = false;
		String msg = "" ; 
		
		//取系统设置表中单位级长
		Map<String, Object> jcMap = dao.getDWJC();   
		String oldJC = (String) jcMap.get("F_ITEM1") ;
		if(oldJC==null)
		{
			oldJC="";
		}
		
		//取已使用的最大级长
		Map<String, Object> jsUsed = dao.getMaxJS();      		
		Object temp =  jsUsed.get("F_LEVEL");
		String temp1 = "";
		int maxJsUsed = 0 ;
		if(temp!=null&&("".equals(temp)==false))
		{
			temp1 = String.valueOf(temp).toString();		
			maxJsUsed = Integer.parseInt(temp1); 
		}		  
		
		//新级长级数
		String newJC = (String) params.get("F_ITEM1");		
		int newJS = newJC.length();     
		try
		{
	    // 1. 如果新旧级长相同，则提示更改成功
		// 2. 如果新旧编码不相同，则判断级数，如果新级长级数小于当前编码已使用的级数，则不能更改
		// 3. 如果级数等于已使用的级数，则判断新级长是否与原级长的前 n位（n位已使用级数）相同，相同则可以修改。
		// 4. 如果新级长级数大于当前编码已使用的级数，则判断 新级长前几位必须和旧级长相同
			if(newJC.equals(oldJC))
			{
				tag = true;
				msg = "更新级长成功!" ;
			}
			else
			{
				if(newJS<=maxJsUsed)
				{
					if(newJS<maxJsUsed)
					{
						msg ="当期编码已使用至第"+temp1+"级，请从第"+String.valueOf(maxJsUsed+1).toString()+"级开始更改!" ;
					}
					else
					{
						String oJC = oldJC.substring(0,maxJsUsed);
						String nJC = newJC.substring(0, maxJsUsed);
						if(oJC.equals(nJC))
						{
							if(dao.setJC(newJC))
							{
								tag = true;
								msg = "修改级长成功!";
							}
							else
							{
								tag = false;
								msg = "修改级长失败!";
							}	
						}
						else
						{
							msg ="当期编码已使用至第"+temp1+"级，请从第"+String.valueOf(maxJsUsed+1).toString()+"级开始更改!" ;	
						}		
					}									
				}
				else
				{
					String oJC = oldJC.substring(0,maxJsUsed);
					String nJC = newJC.substring(0, maxJsUsed);
					if(oJC.equals(nJC))
					{
						if(dao.setJC(newJC))
						{
							tag = true;
							msg = "修改级长成功!";
						}
						else
						{
							tag = false;
							msg = "修改级长失败!";
						}
					}
					else
					{
						msg = "当期编码已使用至第"+temp1+"级，请从第"+String.valueOf(maxJsUsed+1).toString()+"级开始更改!" ;
					}
				}
			}
			

		}
		catch(Exception e)
		{
			msg = "修改级长失败" + e;
		}
		Map<String, Object> resultBean=new HashMap<String, Object>();
		resultBean.put("msg", msg);
		resultBean.put("tag", tag);
		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);

	}		
	/**
	 * 
	 * <p>函数名称：getParentID</p>
	 * <p>功能说明：取父节点id</p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-05-03</p>
	 * <p>作者：陈金滨</p>
	 */
	public ResultModle getParentID(String code) throws Exception
	{				
		Map<String, Object> params = SystemContext.getInParams();
		String child = (String) params.get("F_CODE");
		String parent = dao.getUpBM(child);
		Map<String, Object> childBean = dao.getInfoByCode(child);
		String childID = (String) childBean.get("F_ID");
		Map<String, Object> resultBean= new HashMap<String, Object>();
		resultBean=dao.getInfoByCode(parent);
		if(resultBean==null||"".equals(resultBean))
		{
			resultBean= new HashMap<String, Object>();
			resultBean.put("F_ID", "999");
		}
		resultBean.put("F_CHILD", childID);
		
		return new ResultModle(ResultType.OUTPUT_JSON_STREAM, "user", resultBean);
	}		
	/**
	 * 
	 * <p>函数名称：IsBmNum</p>
	 * <p>功能说明：判断编码是否为数字/p>
	 * <p>参数说明：</p>
	 * <p>创建时间：2012-03-28</p>
	 * <p>作者：陈金滨</p>
	 * @param <Boolen>
	 * @param MaxCode 
	 */
//	public String isBmNum(String code) throws Exception
//	{				
//		boolean result = true;
//		String msg="" ;
//		int lenBm= code.length() ;
//		for(int i=0;i<lenBm;i++)
//		{
//			int CharValue = (int)code.charAt(i);
//			if(CharValue<48||CharValue>57)
//			{
//				result = false ;
//				break ;
//			}
//		}
//		if(!result)
//		{
//			msg = "编码只能为数字!" ;
//		}
//		return msg;
//	}		
}
